The missing else here compared to my commit now means that this line above has no more effect for IR-void-typed vars; irLocal->value is immediately overwritten below with a dummy void-alloca (probably promoted to some dummy i8 storage). And now gets DI infos.

Edit: And additionally caused you to come up with a weird logic for the lifetime-start annotation apparently. So please just try my commit.

Noted wr.t. DI infos, fixed that. Nope:

LLType *lltype = DtoType(type); // void for noreturn
if (lltype->isVoidTy()) {
  irLocal->value = getNullPtr();
} else {
  auto allocainst = type != vd->type ? DtoAlloca(type, vd->toChars())
                                     : DtoAlloca(vd, vd->toChars());
  irLocal->value = allocainst;
      
  gIR->DBuilder.EmitLocalVariable(allocainst, vd);
      
   // The lifetime of a stack variable starts from the point it is declared
    gIR->funcGen().localVariableLifetimeAnnotator.addLocalVariable(
           allocainst, DtoConstUlong(size(type)));
}

still fails with

llvm.lifetime.start can only be used on alloca or poison
  call void @llvm.lifetime.start.p0(ptr captures(none) %0) #4

Adding back in the if

 if (!vd->isParameter() && !varIsSret(vd, gIR->func())) {
  gIR->funcGen().localVariableLifetimeAnnotator.addLocalVariable(
             allocainst, DtoConstUlong(size(type)));
}

then causes it to pass.

alternately if (AFAIU) the entire point of these lifetime annotations is to aid debugging, then we could restrict them to only user variables (i.e. ig more all compiler generated ones beginning with __, e.g. __copytemp which in addition to __tmpfordtor and __sl seems to cover all the bases).

Well IIRC, Phobos couldn't be compiled successfully in #4990 after cherry-picking an earlier version of this PR's commit, but applying both linked commits I linked made it work with LLVM 21 and older versions at least. I think I understood what you were after with the earlier unrelated refactoring (combining the DI and lifetime-start conditions to non-IR-void-typed vars only, without the realAlloca helper var and a 2nd void check), that made sense; it's just that the early return instead of an else branch caused skipping some stuff at the end of the function.

Also note that the sret NRVO case is handled just above in an earlier if:

That's where the lval is set to the sret argument instead of an alloca. And where no lifetime-start annotation is added.

Okay, but as your interesting reduced test case shows, that's not enough. In-place construction can replace a temporary alloca later with an sret argument, as the lvalue of a variable:

According to the -vv log, this is what happens in the last memoizeExpr return statement:

ExpStatement::toIR(): <source>(15)
* D to dwarf stoppoint at line 15, column 5
* DeclarationExp::toElem: (CodepointSet slot = 0;) | T=void
* * DtoDeclarationExp: slot
* * * VarDeclaration
* * * DtoVarDeclaration(vdtype = CodepointSet)
* * * * llvm value for decl:   %2 = alloca %example.CodepointSet, align 1
* * * * expression initializer
* * * * AssignExp::toElem: slot = 0 | (CodepointSet)(CodepointSet = int)
* * * * * VarExp::toElem: slot @ CodepointSet
* * * * * * DtoSymbolAddress ('slot' of type 'CodepointSet')
* * * * * * * a normal variable
* * * * * attempting in-place construction
* * * * * * aborted due to different base types without modifiers
* * * * * IntegerExp::toElem: 0 @ int
* * * * * * IntegerExp::toConstElem: 0 @ int
* * * * * * * value = i32 0
* * * * * performing aggregate zero initialization
ReturnStatement::toIR(): <source>(16)
* D to dwarf stoppoint at line 16, column 5
* attempting in-place construction
* * success, in-place-constructing temporary
* * CommaExp::toElem: (CodepointSet __copytmp3 = (__copytmp3 = slot).this(this)();) , __copytmp3 @ CodepointSet
* * * DeclarationExp::toElem: (CodepointSet __copytmp3 = (__copytmp3 = slot).this(this)();) | T=void
* * * * DtoDeclarationExp: __copytmp3
* * * * * VarDeclaration
* * * * * DtoVarDeclaration(vdtype = CodepointSet)
* * * * * * llvm value for decl:   %3 = alloca %example.CodepointSet, align 1
* * * * * * expression initializer
* * * * * * CallExp::toElem: (__copytmp3 = slot).this(this)() @ void
* * * * * * * DotVarExp::toElem: (__copytmp3 = slot).this(this) @ void()
* * * * * * * * AssignExp::toElem: __copytmp3 = slot | (CodepointSet)(CodepointSet = CodepointSet)
* * * * * * * * * VarExp::toElem: __copytmp3 @ CodepointSet
* * * * * * * * * * DtoSymbolAddress ('__copytmp3' of type 'CodepointSet')
* * * * * * * * * * * a normal variable
* * * * * * * * * attempting in-place construction
* * * * * * * * * VarExp::toElem: slot @ CodepointSet
* * * * * * * * * * DtoSymbolAddress ('slot' of type 'CodepointSet')
* * * * * * * * * * * a normal variable
* * * * * * * * * performing normal assignment (rhs has lvalue elems = 1)
* * * * * * * * * DtoAssign()
* * * * * * * DtoCallFunction()
* * * * * * * * Building type: void()
* * * * * * * * * DtoFunctionType(void())
* * * * * * * * * * x86-64 ABI: Transforming argument types
* * * * * * * * * * Final function type: void ()
* * * * * * * * doing normal arguments
* * * * * * * * Arguments so far: (1)
* * * * * * * * *   %3 = alloca %example.CodepointSet, align 1
* * * * * * * * Function type: void()
* * * VarExp::toElem: __copytmp3 @ CodepointSet
* * * * DtoSymbolAddress ('__copytmp3' of type 'CodepointSet')
* * * * * a normal variable

So __copytmp3 first gets an alloca, and then that lval is IR-replaced with the sret argument later, incl. for the lifetime-start call. Your diagnosis might be right wrt. __copytmp3 apparently not being the frontend-NRVO variable directly; the return expression in the if (__ctfe) block might break it (as the NRVO var must normally be returned in every return statement of the function).

Edit: But there are always going to be remaining non-NRVO cases. So for these lifetime annotations, we might have to skip this in-place construction of sret values from non-NRVO temporaries (edit: oh well, the extra memcpy and different address might break code depending on RVO though...). Or scan the existing uses, to remove the lifetime intrinsic calls (possibly missing the lifetime end calls if they are pushed later on...), before replacing all uses.

Edit2: I think what would probably be best is to pre-set the lval (i.e., getIrLocal(vd, true)->value) of the temporary to the sret argument in toInPlaceConstruction(), before evaluating the comma-expression. [Incl. emitting DI there, as DtoVarDeclaration() wouldn't do it anymore due to isIrLocalCreated(vd).] Instead of replacing all IR uses after a normal evaluation.

Your diagnosis might be right wrt. __copytmp3 apparently not being the frontend-NRVO variable directly; the return expression in the if (__ctfe) block might break it (as the NRVO var must normally be returned in every return statement of the function).

Yeah, an if(false) return ...; also breaks NRVO. I opened a DMD issue for this.

The removal of isRealAlloca was mostly to try to use the type system to fix/make sure I wasn't doing anything stupid with it, but it seems that the replaceAllUsesWith is what is causing it to change type from an AllocaInst to Argument. Thank you for finding that, I thought I was going mad!

It seems to me that the easiest solution then would be to strip the calls to @llvm.lifetime prior to the replaceAllUsesWith, though I don't quite understand what you are trying to say in your Edit2.

Anyway I've added two of the reductions to the test suite (there is another one with __tmpfordtor that I ned to re-run). I'm going away for the weekend, so if you feel like implementing any of your suggestions, please do.

good find!

so if you feel like implementing any of your suggestions, please do.

Okay, I've tried: #5015. I'm pretty sure I've added that replace-all-uses-with hack, so only fair to clean it up now. :)